home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Tools / freeWAIS-sf-1.1 / ir / transprt.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-19  |  12.0 KB  |  481 lines
  1. /* WIDE AREA INFORMATION SERVER SOFTWARE:
  2.    No guarantees or restrictions.  See the readme file for the full standard
  3.    disclaimer.
  4. */
  5.  
  6. /* Copyright (c) CNIDR (see ../COPYRIGHT) */
  7.  
  8.  
  9. #ifndef lint
  10. static char *RCSid = "$Header: /usr/local/ls6/src+data/src/freeWAIS-0.2-sf/ir/RCS/transprt.c,v 1.2 1994/03/08 21:07:02 pfeifer Exp $";
  11. #endif
  12.  
  13. /* this is a krufty transport layer for comm mediums that can not handle
  14.  * all 8 bits of ascii.
  15.  * Written by Harry Morris, modified by brewster.
  16.  * Hexcode written by Steve Swartz
  17.  * 
  18.  */
  19.  
  20. /* to do
  21.  *
  22.  *  compression
  23.  *  encryption
  24.  */
  25.  
  26. /* Change log:
  27.  * $Log: transprt.c,v $
  28.  * Revision 1.2  1994/03/08  21:07:02  pfeifer
  29.  * Patchlevel 04
  30.  *
  31.  * Revision 1.1  1993/02/16  15:05:35  freewais
  32.  * Initial revision
  33.  *
  34.  * Revision 1.2  92/02/12  13:51:34  jonathan
  35.  * Added "$Log" so RCS will put the log message in the header
  36.  * 
  37.  * 
  38.  * 7/7/90 -brewster
  39.  * merged arts and harry's changes 7/7/90 -brewster
  40.  *
  41.  * 11/6/90 -tracy
  42.  * shift 6 bytes starting from [ as IBM gateway program
  43.  * masks out characters [\]^` in input,
  44.  * append H and I to the function names corresponding to the
  45.  * oroginal coding and the modified one. 'I' indicates IBM. 
  46.  */
  47.  
  48. #include "transprt.h"
  49. #include "wmessage.h" 
  50. #include "ustubs.h"
  51.  
  52. /*---------------------------------------------------------------------*/
  53. static char alphaH[] = /* Must be 65 consecutive ascii characters */
  54.   "0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnop";
  55.  
  56.  
  57. /*---------------------------------------------------------------------*/
  58.  
  59. static void hexCodeH _AP((char* data,long* len));
  60.  
  61. static void
  62. hexCodeH(data,len)
  63. char* data;
  64. long* len;
  65. /* compose a message for sending over ascii terminal lines. Input is '*len'
  66.  * binary bytes; output is 'ceiling(*len/3) * 4' characters from alpha[].
  67.  *
  68.  * Encoding goes like this. Let capital letters represent bits:
  69.  * Input bytes:  ABCDEFGH IJKLMNOP QRSTUVWX
  70.  * Output chars: alpha[CDEFGH] alpha[ABIJKL] alpha[QRMNOP] alpha[SRUVWX]
  71.  *
  72.  * 1 byte at end: ABCDEFGH
  73.  * Output chars:  alpha[CDEFGH] alpha[AB0000] alpha[1000000] alpha [1000000]
  74.  *
  75.  * 2 bytes at end: ABCDEFGH IJKLMNOP
  76.  * Output chars:   alpha[CDEFGH] alpha[ABIJKL] alpha[00MNOP] alpha [1000000]
  77.  */
  78. {
  79.   long i, j;
  80.   
  81.   switch (*len % 3)
  82.     {
  83.     case 2:
  84.       i = *len; j = (*len+1)/3 * 4 - 1; *len = j + 1;
  85.       data[j]   = alphaH[64];
  86.       data[j-1] = alphaH[data[i-1] & 0x0f];
  87.       data[j-2] = alphaH[(data[i-2] & 0xc0) >> 2 | (data[i-1] & 0xf0) >> 4];
  88.       data[j-3] = alphaH[data[i-2] & 0x3F];
  89.       break;
  90.     case 1:
  91.       i = *len + 1; j = (*len+2)/3 * 4 - 1; *len = j + 1;
  92.       data[j]   = alphaH[64];
  93.       data[j-1] = alphaH[64];
  94.       data[j-2] = alphaH[(data[i-2] & 0xc0) >> 2];
  95.       data[j-3] = alphaH[data[i-2] & 0x3F];
  96.       break;
  97.     default:
  98.       i = *len + 2; j = (*len)/3 * 4 + 3; *len = j - 3;
  99.       break;
  100.     }
  101.   
  102.   for (i -= 3, j -= 4; i > 0; i -= 3, j -= 4)
  103.     { 
  104.       data[j]   = alphaH[data[i] & 0x3F];
  105.       data[j-1] = alphaH[(data[i] & 0xc0) >> 2 | (data[i-1] & 0x0f)];
  106.       data[j-2] = alphaH[(data[i-2] & 0xc0) >> 2 | (data[i-1] & 0xf0) >> 4];
  107.       data[j-3] = alphaH[data[i-2] & 0x3F];
  108.     }
  109. }
  110.  
  111. /*---------------------------------------------------------------------*/
  112.  
  113. static void hexDecodeH _AP((char* data,long* len));
  114.  
  115. static void
  116. hexDecodeH(data,len)
  117. char* data;
  118. long* len;
  119. /* Incoming data is 'len' letters from alpha[] created by hexCode(). 'len'
  120.  *  will always be divisble by 4. Output is the binary bytes that were 
  121.  *  encoded into 'data'.
  122.  *
  123.  * If alpha[] isn't consecutive ascii characters, then the function moving 
  124.  *  from ascii data to the 'bX' values has to become more complicated than
  125.  *  data[] - alpha[0].
  126.  */
  127. {
  128.   unsigned char b0, b1, b2, b3;
  129.   long i, j;
  130.  
  131.   
  132.   for (i = 3, j = 4; j < *len; i += 3, j += 4)
  133.     {
  134.       b0 = (data[j-4] & 0x07F) - alphaH[0];
  135.       b1 = (data[j-3] & 0x07F) - alphaH[0];
  136.       b2 = (data[j-2] & 0x07F) - alphaH[0];
  137.       b3 = (data[j-1] & 0x07F) - alphaH[0];
  138.       data[i-3] = b0 | (b1 & 0x30) << 2;
  139.       data[i-2] = (b1 & 0x0f) << 4 | (b2 & 0x0f);
  140.       data[i-1] = b3 | (b2 & 0x30) << 2;
  141.     }
  142.  
  143.   *len = *len/4 * 3 - 2;
  144.   b0 = (data[j-4] & 0x07F) - alphaH[0];
  145.   b1 = (data[j-3] & 0x07F) - alphaH[0];
  146.   b2 = (data[j-2] & 0x07F) - alphaH[0];
  147.   b3 = (data[j-1] & 0x07F) - alphaH[0];
  148.   data[i-3] = b0 | (b1 & 0x30) << 2;
  149.  
  150.   if (b2 != 64)    
  151.     {
  152.       data[i-2] = (b1 & 0x0f) << 4 | (b2 & 0x0f);
  153.       (*len)++;
  154.     }
  155.  
  156.   if (b3 != 64)
  157.     {
  158.       data[i-1] = b3 | (b2 & 0x30) << 2;
  159.       (*len)++;
  160.     }
  161. }
  162.  
  163. /*---------------------------------------------------------------------*/
  164.  
  165. void
  166. transportCodeH(data,len)
  167. char* data;
  168. long* len;
  169. /* krufty serial line transport layer - encode in hex and append in cr */
  170. /* Now it also writes a wais packet header on to the front of the packet.
  171.  *   --art 
  172.  */
  173. { 
  174.   hexCodeH(data,len);
  175.   data[*len] = '\r';
  176.   data[*len + 1] = '\0';
  177.   *len += 1;
  178. }
  179.  
  180. /*---------------------------------------------------------------------*/
  181.  
  182. void
  183. transportDecodeH(data,len)
  184. char* data;
  185. long* len;
  186. /* decode above */
  187. /* This does not have to deal with the wais packet header since it has
  188.    been removed at the end of the read.  */
  189. { 
  190.   if (*len == 0)
  191.     return;
  192.     
  193.   *len -= 1;
  194.   hexDecodeH(data,len);
  195. }
  196.  
  197. /*---------------------------------------------------------------------
  198.  Below are the set of transport coding/decoding functions for clients
  199.  dialing through IBM to DowQuest. Unlike the above one that
  200.  uses 65 consecutive ASCII character for the coding/decoding table,
  201.  table entries after charcater 'Z' are shift 6 characters.
  202.  *--------------------------------------------------------------------*/ 
  203.  
  204. #define LAST_NON_SHIFT_CHAR 90
  205. #define SHIFT_OFFSET   6
  206.  
  207. static char alphaI[] = 
  208.   "0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuv";
  209.  
  210.  
  211. static void hexCodeI _AP((char* data,long* len));
  212.  
  213. static void
  214. hexCodeI(data,len)
  215. char* data;
  216. long* len;
  217. /* compose a message for sending over ascii terminal lines. Input is '*len'
  218.  * binary bytes; output is 'ceiling(*len/3) * 4' characters from alpha[].
  219.  *
  220.  * Encoding goes like this. Let capital letters represent bits:
  221.  * Input bytes:  ABCDEFGH IJKLMNOP QRSTUVWX
  222.  * Output chars: alpha[CDEFGH] alpha[ABIJKL] alpha[QRMNOP] alpha[SRUVWX]
  223.  *
  224.  * 1 byte at end: ABCDEFGH
  225.  * Output chars:  alpha[CDEFGH] alpha[AB0000] alpha[1000000] alpha [1000000]
  226.  *
  227.  * 2 bytes at end: ABCDEFGH IJKLMNOP
  228.  * Output chars:   alpha[CDEFGH] alpha[ABIJKL] alpha[00MNOP] alpha [1000000]
  229.  */
  230. {
  231.   long i, j;
  232.   
  233.   switch (*len % 3)
  234.     {
  235.     case 2:
  236.       i = *len; j = (*len+1)/3 * 4 - 1; *len = j + 1;
  237.       data[j]   = alphaI[64];
  238.       data[j-1] = alphaI[data[i-1] & 0x0f];
  239.       data[j-2] = alphaI[(data[i-2] & 0xc0) >> 2 | (data[i-1] & 0xf0) >> 4];
  240.       data[j-3] = alphaI[data[i-2] & 0x3F];
  241.       break;
  242.     case 1:
  243.       i = *len + 1; j = (*len+2)/3 * 4 - 1; *len = j + 1;
  244.       data[j]   = alphaI[64];
  245.       data[j-1] = alphaI[64];
  246.       data[j-2] = alphaI[(data[i-2] & 0xc0) >> 2];
  247.       data[j-3] = alphaI[data[i-2] & 0x3F];
  248.       break;
  249.     default:
  250.       i = *len + 2; j = (*len)/3 * 4 + 3; *len = j - 3;
  251.       break;
  252.     }
  253.   
  254.   for (i -= 3, j -= 4; i > 0; i -= 3, j -= 4)
  255.     { 
  256.       data[j]   = alphaI[data[i] & 0x3F];
  257.       data[j-1] = alphaI[(data[i] & 0xc0) >> 2 | (data[i-1] & 0x0f)];
  258.       data[j-2] = alphaI[(data[i-2] & 0xc0) >> 2 | (data[i-1] & 0xf0) >> 4];
  259.       data[j-3] = alphaI[data[i-2] & 0x3F];
  260.     }
  261. }
  262.  
  263. /*---------------------------------------------------------------------*/
  264.  
  265. static void hexDecodeI _AP((char* data,long * len));
  266.  
  267. static void
  268. hexDecodeI(data,len)
  269. char* data;
  270. long* len;
  271. /* Incoming data is 'len' letters from alpha[] created by hexCode(). 'len'
  272.  *  will always be divisble by 4. Output is the binary bytes that were 
  273.  *  encoded into 'data'.
  274.  *
  275.  * If alpha[] isn't consecutive ascii characters, then the function moving 
  276.  *  from ascii data to the 'bX' values has to become more complicated than
  277.  *  data[] - alpha[0].
  278.  */
  279. {
  280.   unsigned char b0, b1, b2, b3;
  281.   long i, j;
  282.  
  283.   for ( i=0; i < *len ; i++ )
  284.     if ( data[i] > LAST_NON_SHIFT_CHAR ) data[i] -= SHIFT_OFFSET;
  285.   
  286.   for (i = 3, j = 4; j < *len; i += 3, j += 4)
  287.     {
  288.       b0 = (data[j-4] & 0x07F) - alphaI[0];
  289.       b1 = (data[j-3] & 0x07F) - alphaI[0];
  290.       b2 = (data[j-2] & 0x07F) - alphaI[0];
  291.       b3 = (data[j-1] & 0x07F) - alphaI[0];
  292.       data[i-3] = b0 | (b1 & 0x30) << 2;
  293.       data[i-2] = (b1 & 0x0f) << 4 | (b2 & 0x0f);
  294.       data[i-1] = b3 | (b2 & 0x30) << 2;
  295.     }
  296.  
  297.   *len = *len/4 * 3 - 2;
  298.   b0 = (data[j-4] & 0x07F) - alphaI[0];
  299.   b1 = (data[j-3] & 0x07F) - alphaI[0];
  300.   b2 = (data[j-2] & 0x07F) - alphaI[0];
  301.   b3 = (data[j-1] & 0x07F) - alphaI[0];
  302.   data[i-3] = b0 | (b1 & 0x30) << 2;
  303.  
  304.   if (b2 != 64)    
  305.     {
  306.       data[i-2] = (b1 & 0x0f) << 4 | (b2 & 0x0f);
  307.       (*len)++;
  308.     }
  309.  
  310.   if (b3 != 64)
  311.     {
  312.       data[i-1] = b3 | (b2 & 0x30) << 2;
  313.       (*len)++;
  314.     }
  315. }
  316.  
  317. /*---------------------------------------------------------------------*/
  318.  
  319. void
  320. transportCodeI(data,len)
  321. char* data;
  322. long* len;
  323. /* krufty serial line transport layer - encode in hex and append in cr */
  324. /* Now it also writes a wais packet header on to the front of the packet.
  325.  *   --art 
  326.  */
  327. { 
  328.   hexCodeI(data,len);
  329.   data[*len] = '\r';
  330.   data[*len + 1] = '\0';
  331.   *len += 1;
  332. }
  333.  
  334. /*---------------------------------------------------------------------*/
  335.  
  336. void
  337. transportDecodeI(data,len)
  338. char* data;
  339. long* len;
  340. /* decode above */
  341. /* This does not have to deal with the wais packet header since it has
  342.    been removed at the end of the read.  */
  343. { 
  344.   if (*len == 0)
  345.     return;
  346.     
  347.   *len -= 1;
  348.   hexDecodeI(data,len);
  349. }
  350.  
  351. /*---------------------------------------------------------------------*/
  352.  
  353.  
  354. #ifdef NOTDEFINED /* here for back compatibility */
  355.  
  356. static void hexCode _AP((char* data,long * len));
  357.  
  358. static void
  359. hexCode(data,len)
  360. char* data;
  361. long* len;
  362. /* compose a message for sending over ascii terminal lines.  The data is hex,
  363.  */
  364. { long i;
  365.   for (i = *len-1; i >= 0; i--)
  366.     { data[i*2+1] = (data[i]&0x0F) + 'a';
  367.       data[i*2] = ((data[i]>>4)&0x0F) + 'a';
  368.     }
  369.   data[*len*2] = '\0';
  370.   *len = *len * 2;
  371. }
  372.  
  373. /*---------------------------------------------------------------------------*/
  374.  
  375. static void hexDecode _AP((char* data,long * len));
  376.  
  377. static void
  378. hexDecode(data,len)
  379. char* data;
  380. long* len;
  381. /* converts a buffer full of dataLen bytes of hex in place into the
  382. equivalent binary form. len is filled with the actual number of binary bytes.
  383.  */
  384. { long i;
  385.   *len = *len / 2;
  386.   for (i = 0; i < *len; i++)
  387.     { long temp = 0;
  388.       temp = (data[i*2]-'a')<<4;
  389.       temp += data[i*2+1]-'a';
  390.       data[i] = (char)temp;
  391.     }
  392.   data[*len] = '\0';
  393. }
  394.  
  395. #endif /* def NOTDEFINED */
  396. /*---------------------------------------------------------------------------*/
  397.  
  398. boolean
  399. transportCode(encoding,data,len)
  400. long encoding;
  401. char* data;
  402. long* len;
  403. /* krufty serial line transport layer - encode in hex and add trailing nl */
  404. {
  405.   switch (encoding){
  406.   case NO_ENCODING:
  407.     /* do nothing */
  408.     return(true);
  409.   case HEX_ENCODING:
  410.     transportCodeH(data,len);
  411.     return(true);
  412.   case IBM_HEXCODING:
  413.     transportCodeI(data,len);
  414.     return(true);
  415.   default:
  416.     return(false);
  417.   }
  418. }
  419.  
  420. /*---------------------------------------------------------------------------*/
  421.  
  422. boolean
  423. transportDecode(encoding,data,len)
  424. long encoding;
  425. char* data;
  426. long* len;
  427. /* decode above */
  428. {
  429.   switch (encoding){
  430.   case NO_ENCODING:
  431.     /* do nothing */
  432.     return(true);
  433.   case HEX_ENCODING:
  434.     transportDecodeH(data,len);
  435.     return(true);
  436.   case IBM_HEXCODING:
  437.     transportDecodeI(data,len);
  438.     return(true);
  439.   default:
  440.     return(false);
  441.   }
  442. }
  443.  
  444. /*---------------------------------------------------------------------------*/
  445.  
  446.  
  447.  
  448.  
  449.  
  450.  
  451. #ifdef old /* from the bad old days */
  452.  
  453.  
  454. /*---------------------------------------------------------------------------*/
  455.  
  456. void
  457. transportCode(data,len)
  458. char* data;
  459. long* len;
  460. /* krufty serial line transport layer - encode in hex and add trailing nl */
  461. {
  462.   hexCode(data,len);
  463.   data[*len] = '\r';
  464.   data[*len+1] = '\0';
  465. }
  466.  
  467. /*---------------------------------------------------------------------------*/
  468.  
  469. void
  470. transportDecode(data,len)
  471. char* data;
  472. long* len;
  473. /* decode above */
  474. {
  475.   hexDecode(data,len);
  476. }
  477.  
  478. /*---------------------------------------------------------------------------*/
  479.  
  480. #endif /* old */
  481.